Calendar All Tests
Current file: /home/estudydev/workspace/eStudy_svn/web/common/classes/class.dateselection.inc.php
Legend: executed not executed dead code

  Coverage
  Classes Methods Lines
Total
0.00 %0.00%
0.00% 0 / 1
0.00 %0.00%
0.00% 0 / 10
0.00 %0.00%
0.00% 0 / 183
 
DateSelection
0.00 %0.00%
0.00% 0 / 1
0.00 %0.00%
0.00% 0 / 10
0.00 %0.00%
0.00% 0 / 183
 public function DateSelection($tag, $monat, $jahr, $stunde = 0, $minute = 0)
0.00 %0.00%
0.00% 0 / 1
0.00 %0.00%
0.00% 0 / 21
 public function setDate($tag, $monat, $jahr)
0.00 %0.00%
0.00% 0 / 1
0.00 %0.00%
0.00% 0 / 15
 public function getUnixTimeStamp()
0.00 %0.00%
0.00% 0 / 1
0.00 %0.00%
0.00% 0 / 1
 public function setTime($stunde, $minute)
0.00 %0.00%
0.00% 0 / 1
0.00 %0.00%
0.00% 0 / 7
 public function get($what)
0.00 %0.00%
0.00% 0 / 1
0.00 %0.00%
0.00% 0 / 11
 public function printCalender($optionName, $mode = 'all')
0.00 %0.00%
0.00% 0 / 1
0.00 %0.00%
0.00% 0 / 29
 public function getMaxDays($month, $year)
0.00 %0.00%
0.00% 0 / 1
0.00 %0.00%
0.00% 0 / 5
 public function printPart($optionName, $what)
0.00 %0.00%
0.00% 0 / 1
0.00 %0.00%
0.00% 0 / 82
 public function defaultStrings()
0.00 %0.00%
0.00% 0 / 1
0.00 %0.00%
0.00% 0 / 6
 public function clearStrings()
0.00 %0.00%
0.00% 0 / 1
0.00 %0.00%
0.00% 0 / 6


       1                 : <?php                                                                                                                                                          
       2                 : /*--------------------------------------------------------------------------+                                                                                  
       3                 : This file is part of eStudy.                                                                                                                                   
       4                 : common/classes/class.calender.inc.php                                                                                                                          
       5                 : - Modulgruppe:  Voting                                                                                                                                         
       6                 : - Beschreibung: Datumsauswahl mit Pulldownmenüs                                                                                                               
       7                 : - Version:      1.1, 29/11/03                                                                                                                                  
       8                 : - Autor(en):    Christian Gerhardt <case42@gmx.net>                                                                                                            
       9                 : +---------------------------------------------------------------------------+                                                                                  
      10                 : This program is free software; you can redistribute it and/or                                                                                                  
      11                 : modify it under the terms of the GNU General Public License                                                                                                    
      12                 : as published by the Free Software Foundation; either version 2                                                                                                 
      13                 : of the License, or any later version.                                                                                                                          
      14                 : +---------------------------------------------------------------------------+                                                                                  
      15                 : This program is distributed in the hope that it will be useful,                                                                                                
      16                 : but WITHOUT ANY WARRANTY; without even the implied warranty of                                                                                                 
      17                 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                                                                                  
      18                 : GNU General Public License for more details.                                                                                                                   
      19                 : You should have received a copy of the GNU General Public License                                                                                              
      20                 : along with this program; if not, write to the Free Software                                                                                                    
      21                 : Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.                                                                                    
      22                 : +--------------------------------------------------------------------------*/                                                                                  
      23                 : /**                                                                                                                                                            
      24                 :  * In dieser Datei wird die Klasse Calender implementiert.                                                                                                     
      25                 :  * @package eStudy.Framework                                                                                                                                   
      26                 :  * @author Christian Gerhardt <case42@gmx.net>                                                                                                                 
      27                 :  * @version 1.1 29.11.03                                                                                                                                       
      28                 :  */                                                                                                                                                            
      29                 : /**                                                                                                                                                            
      30                 :  * Klasse zum ausgeben einer Datumsauswahl per Pulldownmenü.                                                                                                  
      31                 :  * Es werden Pulldownmenüs erzeugt, mit denen man ein bestimmtes Datum auswählen kann.<br>                                                                   
      32                 :  * Falls {@link $autoUpdate <b>$autoUpdate</b>} auf <i>true</i> steht, wird nach jeder Auswahl                                                                 
      33                 :  * des Monats oder des Jahres die Seite neu geladen um evtl. Veränderungen im Bereich                                                                         
      34                 :  * der Tagesauswahl auszugeben. (z.B. Schaltjahre)<br>                                                                                                         
      35                 :  * Damit dies dann auch funktioniert, muß der Wert {@link $formName <b>$formName</b>} auf den Namen                                                           
      36                 :  * des verwendeten Formulars gesetzt werden, da sonst das verwendete Javascript sich nicht selbst                                                              
      37                 :  * aufrufen kann. <br>                                                                                                                                         
      38                 :  * Das am anfang ausgewählte Datum wird über den Konstruktor eingegeben und kann auch später                                                                
      39                 :  * noch geändert werden.<br>                                                                                                                                  
      40                 :  * Die Attribute die auf -String enden, sind Strings die direkt vor dem jeweiligen Pulldownmenü                                                               
      41                 :  * ausgegeben werden. So ist es möglich zuätzliche Informationen oder auch Formatierungsangaben                                                              
      42                 :  * auszugeben.<br>                                                                                                                                             
      43                 :  * Mit {@link $printCalender() <b>$printCalender()</b>} werden die Pulldownmenüs an den                                                                       
      44                 :  * Browser geschickt. Diese Methode verlangt einen <i>OptionName</i> als Argument. Über diesen <i>OptionName</i>                                              
      45                 :  * ist die Datumsauswahl später in der <b>$_POST</b> Variablen wiederzufinden.<br>                                                                            
      46                 :  * Diese Funktionalität ist ab Version 1.1 Javascript sicher!                                                                                                 
      47                 :  *                                                                                                                                                             
      48                 :  * @package eStudy.Framework                                                                                                                                   
      49                 :  * @author Christian Gerhardt <case42@gmx.net>                                                                                                                 
      50                 :  * @version 1.1, 29.11.03                                                                                                                                      
      51                 :  */                                                                                                                                                            
      52                 : class DateSelection {                                                                                                                                          
      53                 :     /**                                                                                                                                                        
      54                 :      * der voreingestellte Tag                                                                                                                                 
      55                 :      *                                                                                                                                                         
      56                 :      * @access private                                                                                                                                         
      57                 :      * @var integer                                                                                                                                            
      58                 :      */                                                                                                                                                        
      59                 :     var $tag;                                                                                                                                                  
      60                 :     /**                                                                                                                                                        
      61                 :      * der voreingestellte Monat                                                                                                                               
      62                 :      *                                                                                                                                                         
      63                 :      * @access private                                                                                                                                         
      64                 :      * @var integer                                                                                                                                            
      65                 :      */                                                                                                                                                        
      66                 :     var $monat;                                                                                                                                                
      67                 :     /**                                                                                                                                                        
      68                 :      * das voreingestellte Jahr                                                                                                                                
      69                 :      *                                                                                                                                                         
      70                 :      * @access private                                                                                                                                         
      71                 :      * @var integer                                                                                                                                            
      72                 :      */                                                                                                                                                        
      73                 :     var $jahr;                                                                                                                                                 
      74                 :     /**                                                                                                                                                        
      75                 :      * Die voreingestellte Minute                                                                                                                              
      76                 :      *                                                                                                                                                         
      77                 :      * @access private                                                                                                                                         
      78                 :      * @var integer                                                                                                                                            
      79                 :      */                                                                                                                                                        
      80                 :     var $minute;                                                                                                                                               
      81                 :     /**                                                                                                                                                        
      82                 :      * Die voreingestellte Stunde                                                                                                                              
      83                 :      *                                                                                                                                                         
      84                 :      * @access private                                                                                                                                         
      85                 :      * @var integer                                                                                                                                            
      86                 :      */                                                                                                                                                        
      87                 :     var $stunde;                                                                                                                                               
      88                 :     /**                                                                                                                                                        
      89                 :      * Die Namen der Monate                                                                                                                                    
      90                 :      *                                                                                                                                                         
      91                 :      * @access private                                                                                                                                         
      92                 :      * @var array                                                                                                                                              
      93                 :      */                                                                                                                                                        
      94                 :     var $monatNamen;                                                                                                                                           
      95                 :     /**                                                                                                                                                        
      96                 :      * Die Jahresspanne die ausgewählt werden kann.                                                                                                           
      97                 :      * diese geht von $jahr-$yearRange bis $jahr+$yearRange                                                                                                    
      98                 :      *                                                                                                                                                         
      99                 :      * @access public                                                                                                                                          
     100                 :      * @var integer                                                                                                                                            
     101                 :      */                                                                                                                                                        
     102                 :     var $yearRange;                                                                                                                                            
     103                 :     /**                                                                                                                                                        
     104                 :      * Das Verschieben der Jahresspanne nach oben.                                                                                                             
     105                 :      * wenn $shift = $yearRange ist, werden keine Jahreszahlen                                                                                                 
     106                 :      * vor dem voreingestellten Jahr ausgegeben.                                                                                                               
     107                 :      *                                                                                                                                                         
     108                 :      * @access public                                                                                                                                          
     109                 :      * @var integer                                                                                                                                            
     110                 :      */                                                                                                                                                        
     111                 :     var $shift;                                                                                                                                                
     112                 :     /**                                                                                                                                                        
     113                 :      * Gibt an ob die Anzeige automatisch aktualisiert werden soll wenn ein wert gewählt wurde.                                                               
     114                 :      * Das bedeutet, das z.b. nach der Auswahl eines Monats auch nur die maximale anzahl                                                                       
     115                 :      * an Tagen für diesen Monat auswählbar sind. (für Februar z.b. 28)                                                                                     
     116                 :      *                                                                                                                                                         
     117                 :      * @access public                                                                                                                                          
     118                 :      * @var bool                                                                                                                                               
     119                 :      */                                                                                                                                                        
     120                 :     var $autoUpdate;                                                                                                                                           
     121                 :     /**                                                                                                                                                        
     122                 :      * steht vor der Ausgabe der Tag-Auswahl                                                                                                                   
     123                 :      *                                                                                                                                                         
     124                 :      * @access public                                                                                                                                          
     125                 :      * @var string                                                                                                                                             
     126                 :      */                                                                                                                                                        
     127                 :     var $dayString;                                                                                                                                            
     128                 :     /**                                                                                                                                                        
     129                 :      * String - steht vor der Ausgabe der Monats-Auswahl                                                                                                       
     130                 :      *                                                                                                                                                         
     131                 :      * @access public                                                                                                                                          
     132                 :      * @var string                                                                                                                                             
     133                 :      */                                                                                                                                                        
     134                 :     var $monthString;                                                                                                                                          
     135                 :     /**                                                                                                                                                        
     136                 :      * steht vor der Ausgabe der Jahres-Auswahl                                                                                                                
     137                 :      *                                                                                                                                                         
     138                 :      * @access public                                                                                                                                          
     139                 :      * @var string                                                                                                                                             
     140                 :      */                                                                                                                                                        
     141                 :     var $yearString;                                                                                                                                           
     142                 :     /**                                                                                                                                                        
     143                 :      * steht vor der Ausgabe der Minuten-Auswahl                                                                                                               
     144                 :      *                                                                                                                                                         
     145                 :      * @access public                                                                                                                                          
     146                 :      * @var string                                                                                                                                             
     147                 :      */                                                                                                                                                        
     148                 :     var $minuteString;                                                                                                                                         
     149                 :     /**                                                                                                                                                        
     150                 :      * steht vor der Ausgabe der Stunden-Auswahl                                                                                                               
     151                 :      *                                                                                                                                                         
     152                 :      * @access public                                                                                                                                          
     153                 :      * @var string                                                                                                                                             
     154                 :      */                                                                                                                                                        
     155                 :     var $hourString;                                                                                                                                           
     156                 :     /**                                                                                                                                                        
     157                 :      * Der Name des Formulars in dem die Datumsauswahl erscheinen soll.                                                                                        
     158                 :      * Wichtig für autoupdate!!                                                                                                                               
     159                 :      *                                                                                                                                                         
     160                 :      * @access public                                                                                                                                          
     161                 :      * @var string                                                                                                                                             
     162                 :      */                                                                                                                                                        
     163                 :     var $formName;                                                                                                                                             
     164                 :     /**                                                                                                                                                        
     165                 :      * Konstruktor der Defaultwerte einstellt und die voreingestellten Werte übernimmt                                                                        
     166                 :      *                                                                                                                                                         
     167                 :      * @param integer $tag - der Tag der voreingestellt ist                                                                                                    
     168                 :      * @param integer $monat - der Monat der voreingestellt ist                                                                                                
     169                 :      * @param integer $jahr - das Jahr das voreingestellt ist                                                                                                  
     170                 :      * @param integer $stunde - die Stunde die voreingestellt ist, default = 0                                                                                 
     171                 :      * @param integer $minute - die Minute die voreingestellt ist, default = 0                                                                                 
     172                 :      */                                                                                                                                                        
     173                 :     function DateSelection($tag, $monat, $jahr, $stunde = 0, $minute = 0) {                                                                                    
     174                 :         // Defaultwerte                                                                                                                                        
     175               0 :         $this->formName = 'void';                                                                                                                              
     176               0 :         $this->yearRange = 5;                                                                                                                                  
     177               0 :         $this->shift = 0;                                                                                                                                      
     178               0 :         $this->monatNamen = array(1 => 'Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember');
     179               0 :         $this->defaultStrings();                                                                                                                               
     180               0 :         $this->autoUpdate = false;                                                                                                                             
     181                 :         // Werte übernehmen                                                                                                                                   
     182               0 :         if ($this->setDate($tag, $monat, $jahr) === false) {                                                                                                   
     183               0 :             $this->tag = 1;                                                                                                                                    
     184               0 :             $this->monat = 1;                                                                                                                                  
     185               0 :             $this->jahr = 1970;                                                                                                                                
     186               0 :         } else {                                                                                                                                               
     187               0 :             $this->tag = $tag;                                                                                                                                 
     188               0 :             $this->monat = $monat;                                                                                                                             
     189               0 :             $this->jahr = $jahr;                                                                                                                               
     190                 :         }                                                                                                                                                      
     191               0 :         if ($this->setTime($stunde, $minute) === false) {                                                                                                      
     192               0 :             $this->minute = 0;                                                                                                                                 
     193               0 :             $this->stunde = 0;                                                                                                                                 
     194               0 :         } else {                                                                                                                                               
     195               0 :             $this->minute = $minute;                                                                                                                           
     196               0 :             $this->stunde = $stunde;                                                                                                                           
     197                 :         }                                                                                                                                                      
     198               0 :     }                                                                                                                                                          
     199                 :     /**                                                                                                                                                        
     200                 :      * Setzt das Datum das eingestellt sein soll                                                                                                               
     201                 :      * Üerprüft das Datum auf Richtigkeit und nimmt gegebenenfalls Veränderungungen vor.                                                                    
     202                 :      * Wenn der $tag positiv ist, wird eine zuhohe eingabe automatisch auf den höchst                                                                         
     203                 :      * möglichen Wert für diesen Monat gesetzt. Es wird auch überprüft ob ein Schaltjahr                                                                   
     204                 :      * vorliegt.                                                                                                                                               
     205                 :      *                                                                                                                                                         
     206                 :      * @access public                                                                                                                                          
     207                 :      * @param  integer $tag    - der Tag der voreingestellt ist                                                                                                
     208                 :      * @param  integer $monat  - der Monat der voreingestellt ist                                                                                              
     209                 :      * @param  integer $jahr   - das Jahr das voreingestellt ist                                                                                               
     210                 :      * @return bool            - ob die eingegebenen Werte gültig waren                                                                                       
     211                 :      */                                                                                                                                                        
     212                 :     function setDate($tag, $monat, $jahr) {                                                                                                                    
     213               0 :         if (is_numeric($tag) and is_numeric($monat) and is_numeric($jahr)) {                                                                                   
     214                 :             // das Datum prüfen ob es gültig ist                                                                                                             
     215               0 :             if (checkdate($monat, $tag, $jahr)) {                                                                                                              
     216               0 :                 $this->tag = $tag;                                                                                                                             
     217               0 :                 $this->monat = $monat;                                                                                                                         
     218               0 :                 $this->jahr = $jahr;                                                                                                                           
     219               0 :                 return true;                                                                                                                                   
     220                 :             } else {                                                                                                                                           
     221                 :                 // prüfen ob die eingaben gültig waren                                                                                                       
     222               0 :                 if ($tag > 0 && $monat > 0 && $monat < 13 && $jahr > 1902 && $jahr < 2037) {                                                                   
     223                 :                     // hier kann der einzige fehler nur noch sein, das der Tag für diesen Monat nicht stimmt                                                  
     224                 :                     // also z.b. 31 ist für einen 30-Tage Monat                                                                                               
     225                 :                     do {                                                                                                                                       
     226                 :                         // verringere den Tag so lange bis ein gültiges Datum raus kommt                                                                      
     227               0 :                         $tag--;                                                                                                                                
     228                 :                     }                                                                                                                                          
     229               0 :                     while (!checkdate($monat, $tag, $jahr));                                                                                                   
     230               0 :                     $this->tag = $tag;                                                                                                                         
     231               0 :                     $this->monat = $monat;                                                                                                                     
     232               0 :                     $this->jahr = $jahr;                                                                                                                       
     233               0 :                     return true;                                                                                                                               
     234                 :                 }                                                                                                                                              
     235                 :             }                                                                                                                                                  
     236               0 :         }                                                                                                                                                      
     237               0 :         return false;                                                                                                                                          
     238                 :     }                                                                                                                                                          
     239                 :     /**                                                                                                                                                        
     240                 :      * gibt den Unix-Time-Stamp für die eingestellte zeit zurück                                                                                             
     241                 :      *                                                                                                                                                         
     242                 :      * @access public                                                                                                                                          
     243                 :      * @return integer                                                                                                                                         
     244                 :      */                                                                                                                                                        
     245                 :     function getUnixTimeStamp() {                                                                                                                              
     246               0 :         return mktime($this->stunde, $this->minute, 0, $this->monat, $this->tag, $this->jahr);                                                                 
     247                 :     }                                                                                                                                                          
     248                 :     /**                                                                                                                                                        
     249                 :      * setzt die Uhrzeit die eingestellt werden soll und überprüft diese auf Richtigkeit                                                                     
     250                 :      *                                                                                                                                                         
     251                 :      * @access public                                                                                                                                          
     252                 :      * @param  integer $stunde - die Stunde die voreingestellt ist                                                                                             
     253                 :      * @param  integer $minute - die Minute die voreingestellt ist                                                                                             
     254                 :      * @return bool            - ob die eingegebenen Werte gültig waren                                                                                       
     255                 :      */                                                                                                                                                        
     256                 :     function setTime($stunde, $minute) {                                                                                                                       
     257               0 :         if (is_numeric($stunde) and is_numeric($minute)) {                                                                                                     
     258               0 :             if ($minute >= 0 && $minute < 60 && $stunde >= 0 && $stunde < 25) {                                                                                
     259               0 :                 $this->stunde = $stunde;                                                                                                                       
     260               0 :                 $this->minute = $minute;                                                                                                                       
     261               0 :                 return true;                                                                                                                                   
     262                 :             }                                                                                                                                                  
     263               0 :         }                                                                                                                                                      
     264               0 :         return false;                                                                                                                                          
     265                 :     }                                                                                                                                                          
     266                 :     /**                                                                                                                                                        
     267                 :      * Mit dieser Funktion kann man die Werte der Attribute abfragen.                                                                                          
     268                 :      *                                                                                                                                                         
     269                 :      * @access public                                                                                                                                          
     270                 :      * @param  string $what    - Welches Attribut man haben möchte. Mögliche Werte sind:                                                                     
     271                 :      *                           'jahr', 'tag','monat','minute','stunde'                                                                                       
     272                 :      * @return integer         - der Wert der abgefragt wurde                                                                                                  
     273                 :      */                                                                                                                                                        
     274                 :     function get($what) {                                                                                                                                      
     275                 :         switch ($what) {                                                                                                                                       
     276               0 :             case 'jahr':                                                                                                                                       
     277               0 :                 return $this->jahr;                                                                                                                            
     278               0 :             case 'tag':                                                                                                                                        
     279               0 :                 return $this->tag;                                                                                                                             
     280               0 :             case 'monat':                                                                                                                                      
     281               0 :                 return $this->monat;                                                                                                                           
     282               0 :             case 'stunde':                                                                                                                                     
     283               0 :                 return $this->stunde;                                                                                                                          
     284               0 :             case 'minute':                                                                                                                                     
     285               0 :                 return $this->minute;                                                                                                                          
     286                 :         }                                                                                                                                                      
     287               0 :     }                                                                                                                                                          
     288                 :     /**                                                                                                                                                        
     289                 :      * gibt die PulldownMenüs aus                                                                                                                             
     290                 :      *                                                                                                                                                         
     291                 :      * @param string $optionName - Name der Variable über die in $_POST auf die Auswahl zugegriffen wird                                                      
     292                 :      *                            die Variablen haben folgendes Aussehen:                                                                                      
     293                 :      *                            $optionName.'_day'     - für den Tag                                                                                        
     294                 :      *                            $optionName.'_month'   - für den Monat                                                                                      
     295                 :      *                            $optionName.'_year'    - für das Jahr                                                                                       
     296                 :      *                            $optionName.'_minute'  - für die Minute                                                                                     
     297                 :      *                            $optionName.'_hour'    - für die Stunde                                                                                     
     298                 :      * @param string $mode - mögliche Modi sind:                                                                                                              
     299                 :      *                       'all'        - Uhrzeit und Datum werden ausgegeben                                                                                
     300                 :      *                       'allExt'     - Uhrzeit und Datum werden ausgegeben, Monate werden ausgeschrieben                                                  
     301                 :      *                       'date'       - das Datum wird ausgegeben                                                                                          
     302                 :      *                       'dateExt'    - das Datum wird ausgegeben, Monate werden ausgeschrieben                                                            
     303                 :      *                       'time'       - die Uhrzeit wird ausgegeben                                                                                        
     304                 :      * @return void                                                                                                                                            
     305                 :      */                                                                                                                                                        
     306                 :     function printCalender($optionName, $mode = 'all') {                                                                                                       
     307                 :         switch ($mode) {                                                                                                                                       
     308               0 :             case 'all':                                                                                                                                        
     309               0 :                 $this->printPart($optionName, 'day');                                                                                                          
     310               0 :                 $this->printPart($optionName, 'month');                                                                                                        
     311               0 :                 $this->printPart($optionName, 'year');                                                                                                         
     312               0 :                 $this->printPart($optionName, 'hour');                                                                                                         
     313               0 :                 $this->printPart($optionName, 'minute');                                                                                                       
     314               0 :                 break;                                                                                                                                         
     315                 :                                                                                                                                                                
     316               0 :             case 'allExt':                                                                                                                                     
     317               0 :                 $this->printPart($optionName, 'day');                                                                                                          
     318               0 :                 $this->printPart($optionName, 'monthExt');                                                                                                     
     319               0 :                 $this->printPart($optionName, 'year');                                                                                                         
     320               0 :                 $this->printPart($optionName, 'hour');                                                                                                         
     321               0 :                 $this->printPart($optionName, 'minute');                                                                                                       
     322               0 :                 break;                                                                                                                                         
     323                 :                                                                                                                                                                
     324               0 :             case 'date':                                                                                                                                       
     325               0 :                 $this->printPart($optionName, 'day');                                                                                                          
     326               0 :                 $this->printPart($optionName, 'month');                                                                                                        
     327               0 :                 $this->printPart($optionName, 'year');                                                                                                         
     328               0 :                 break;                                                                                                                                         
     329                 :                                                                                                                                                                
     330               0 :             case 'dateExt':                                                                                                                                    
     331               0 :                 $this->printPart($optionName, 'day');                                                                                                          
     332               0 :                 $this->printPart($optionName, 'monthExt');                                                                                                     
     333               0 :                 $this->printPart($optionName, 'year');                                                                                                         
     334               0 :                 break;                                                                                                                                         
     335                 :                                                                                                                                                                
     336               0 :             case 'time':                                                                                                                                       
     337               0 :                 $this->printPart($optionName, 'hour');                                                                                                         
     338               0 :                 $this->printPart($optionName, 'minute');                                                                                                       
     339               0 :                 break;                                                                                                                                         
     340                 :         }                                                                                                                                                      
     341               0 :     }                                                                                                                                                          
     342                 :     /**                                                                                                                                                        
     343                 :      * berechnet die Anzahl Tage die ein Monat in einem bestimmten Jahr hat(Schaltjahre)                                                                       
     344                 :      *                                                                                                                                                         
     345                 :      * @access protected                                                                                                                                       
     346                 :      * @param  integer $month  - der Monat                                                                                                                     
     347                 :      * @param  integer $year   - das Jahr                                                                                                                      
     348                 :      * @return integer         - die anzahl Tage                                                                                                               
     349                 :      */                                                                                                                                                        
     350                 :     function getMaxDays($month, $year) {                                                                                                                       
     351               0 :         (integer)$day = 31; // die maximal mögliche anzahl an Tagen in einem Monat                                                                            
     352               0 :         while (!checkdate((integer)$month, $day, (integer)$year)) {                                                                                            
     353                 :             // so lange bis ein gültiges Datum raus kommt                                                                                                     
     354               0 :             $day--;                                                                                                                                            
     355               0 :         }                                                                                                                                                      
     356               0 :         return $day;                                                                                                                                           
     357                 :     }                                                                                                                                                          
     358                 :     /**                                                                                                                                                        
     359                 :      * gibt einen Teil der PulldownMenüs aus                                                                                                                  
     360                 :      *                                                                                                                                                         
     361                 :      * @access protected                                                                                                                                       
     362                 :      * @param string $optionName - Name der Variable über die in $_POST auf die Auswahl zugegriffen wird                                                      
     363                 :      *                           die Variablen haben folgendes Aussehen:                                                                                       
     364                 :      *                           $optionName.'_day' - für den Tag                                                                                             
     365                 :      *                           $optionName.'_month' - für den Monat                                                                                         
     366                 :      *                           $optionName.'_year' - für das Jahr                                                                                           
     367                 :      *                           $optionName.'_minute' - für die Minute                                                                                       
     368                 :      *                           $optionName.'_hour' - für die Stunde                                                                                         
     369                 :      * @param string $what - welchen Teil der PulldownMenüs ausgegeben werden soll                                                                            
     370                 :      *                       mögliche Werte sind:                                                                                                             
     371                 :      *                       'day'       - gibt das Tag-Menü aus                                                                                              
     372                 :      *                       'month'     - gibt das Monat-Menü aus                                                                                            
     373                 :      *                       'monthExt'  - gibt das Monat-Menü aus, die Monate werden ausgeschrieben                                                          
     374                 :      *                       'hour'      - gibt das Stunde-Menü aus                                                                                           
     375                 :      *                       'minute'    - gibt das Minuten-Menü aus                                                                                          
     376                 :      * @return void                                                                                                                                            
     377                 :      */                                                                                                                                                        
     378                 :     function printPart($optionName, $what) {                                                                                                                   
     379                 :         switch ($what) {                                                                                                                                       
     380               0 :             case 'year':                                                                                                                                       
     381                 :                 // ausgabe von dem was vor dem Jahres-Menü stehen soll                                                                                        
     382               0 :                 echo $this->yearString." ";                                                                                                                    
     383                 :                 // generiere den Menü                                                                                                                         
     384                 :                 // setze den Variablen Namen über den später in $_POST daruf zugegriffen werden kann                                                         
     385               0 :                 echo "<p class='pForm'><select name='".$optionName."_year' ";                                                                                  
     386                 :                 // falls autoUpdate dann binde dieses javascript ein                                                                                           
     387               0 :                 if ($this->autoUpdate === true) echo " onchange='document.getElementById[\"".$this->formName."\"].submit();'";                                 
     388               0 :                 echo ">\n";                                                                                                                                    
     389                 :                 // Berechnung der Jahresspanne die ausgegeben werden soll                                                                                      
     390               0 :                 $i = $this->jahr+$this->shift-$this->yearRange;                                                                                                
     391                 :                 // sichergehen das auch das ausgewählte jahr angezeigt wird, für den fall das shift                                                          
     392                 :                 // zu groß ist                                                                                                                                
     393               0 :                 if ($i > $this->jahr) $i = $this->jahr;                                                                                                        
     394               0 :                 for ($i ; $i < $this->jahr+$this->yearRange+$this->shift ; $i++) {                                                                             
     395               0 :                     if ($i > 9999) break;                                                                                                                      
     396                 :                                                                                                                                                                
     397               0 :                     echo "<option";                                                                                                                            
     398               0 :                     if ($i == $this->jahr) echo " selected='selected'";                                                                                        
     399               0 :                     echo ">".$i."</option>\n";                                                                                                                 
     400               0 :                 }                                                                                                                                              
     401               0 :                 echo "</select></p>";                                                                                                                          
     402               0 :                 break;                                                                                                                                         
     403                 :                                                                                                                                                                
     404               0 :             case 'day':                                                                                                                                        
     405                 :                 // ausgabe von dem was vor dem Tages-Menü stehen soll                                                                                         
     406               0 :                 echo $this->dayString." \n";                                                                                                                   
     407               0 :                 $maxDays = 31;                                                                                                                                 
     408                 :                 // falls autoUpdate dann aktiviere das javascript                                                                                              
     409                 :                 // und aktualisiere die maximale Anzahl an Tagen in diesem Monat                                                                               
     410               0 :                 if ($this->autoUpdate === true) {                                                                                                              
     411               0 :                     $maxDays = $this->getMaxDays($this->monat, $this->jahr);                                                                                   
     412               0 :                 }                                                                                                                                              
     413                 :                 // generiere das Menü                                                                                                                         
     414                 :                 // setze den Variablen Namen über den später in $_POST daruf zugegriffen werden kann                                                         
     415               0 :                 echo "<p class='pForm'><select name='".$optionName."_day'>\n";                                                                                 
     416               0 :                 for ($i = 1 ; $i <= 31 ; $i++) {                                                                                                               
     417               0 :                     echo "<option ";                                                                                                                           
     418               0 :                     if ($i == $this->tag) echo "selected='selected'";                                                                                          
     419               0 :                     echo ">".$i."</option>\n";                                                                                                                 
     420               0 :                 }                                                                                                                                              
     421               0 :                 echo "</select></p>\n";                                                                                                                        
     422                 :                 //echo "</noscript>";                                                                                                                          
     423               0 :                 break;                                                                                                                                         
     424                 :                                                                                                                                                                
     425               0 :             case 'month':                                                                                                                                      
     426                 :                 // ausgabe von dem was vor dem Monats-Menü stehen soll                                                                                        
     427               0 :                 echo $this->monthString." ";                                                                                                                   
     428                 :                 // generiere den Menü                                                                                                                         
     429                 :                 // setze den Variablen Namen über den später in $_POST daruf zugegriffen werden kann                                                         
     430               0 :                 echo "<p class='pForm'><select name='".$optionName."_month'";                                                                                  
     431                 :                 // falls autoUpdate dann aktiviere das javascript                                                                                              
     432               0 :                 if ($this->autoUpdate === true) echo " onchange='document.getElementById[\"".$this->formName."\"].submit();'";                                 
     433               0 :                 echo ">\n";                                                                                                                                    
     434               0 :                 $i = 1;                                                                                                                                        
     435               0 :                 for ($i ; $i < 13 ; $i++) {                                                                                                                    
     436               0 :                     echo "<option ";                                                                                                                           
     437               0 :                     if ($i == $this->monat) echo "selected='selected'";                                                                                        
     438               0 :                     echo ">".$i."</option>\n";                                                                                                                 
     439               0 :                 }                                                                                                                                              
     440               0 :                 echo "</select></p>";                                                                                                                          
     441               0 :                 break;                                                                                                                                         
     442                 :                                                                                                                                                                
     443               0 :             case 'monthExt':                                                                                                                                   
     444                 :                 // ausgabe von dem was vor dem Monats-Menü stehen soll                                                                                        
     445               0 :                 echo $this->monthString." ";                                                                                                                   
     446                 :                 // generiere den Menü                                                                                                                         
     447                 :                 // setze den Variablen Namen über den später in $_POST daruf zugegriffen werden kann                                                         
     448               0 :                 echo "<p class='pForm'><select name='".$optionName."_month'";                                                                                  
     449                 :                 // falls autoUpdate dann aktiviere das javascript                                                                                              
     450               0 :                 if ($this->autoUpdate === true) echo " onchange='document.getElementById[\"".$this->formName."\"].submit();'";                                 
     451               0 :                 echo ">\n";                                                                                                                                    
     452               0 :                 $i = 1;                                                                                                                                        
     453               0 :                 for ($i ; $i < 13 ; $i++) {                                                                                                                    
     454               0 :                     echo "<option value='".$i."' ";                                                                                                            
     455               0 :                     if ($i == $this->monat) echo "selected='selected'";                                                                                        
     456               0 :                     echo ">".Data::toHTML($this->monatNamen[$i], false) ."</option>\n";                                                                        
     457               0 :                 }                                                                                                                                              
     458               0 :                 echo "</select></p>";                                                                                                                          
     459               0 :                 break;                                                                                                                                         
     460                 :                                                                                                                                                                
     461               0 :             case 'hour':                                                                                                                                       
     462                 :                 // ausgabe von dem was vor dem Stunden-Menü stehen soll                                                                                       
     463               0 :                 echo $this->hourString." ";                                                                                                                    
     464                 :                 // generiere den Menü                                                                                                                         
     465                 :                 // setze den Variablen Namen über den später in $_POST daruf zugegriffen werden kann                                                         
     466               0 :                 echo "<p class='pForm'><select name='".$optionName."_hour'";                                                                                   
     467                 :                 // falls autoUpdate dann aktiviere das javascript                                                                                              
     468               0 :                 if ($this->autoUpdate === true) echo " onchange='document.getElementById[\"".$this->formName."\"].submit();'";                                 
     469               0 :                 echo ">\n";                                                                                                                                    
     470               0 :                 $i = 0;                                                                                                                                        
     471               0 :                 for ($i ; $i < 24 ; $i++) {                                                                                                                    
     472               0 :                     echo "<option ";                                                                                                                           
     473               0 :                     if ($i == $this->stunde) echo "selected='selected'";                                                                                       
     474               0 :                     echo ">".$i."</option>\n";                                                                                                                 
     475               0 :                 }                                                                                                                                              
     476               0 :                 echo "</select></p>";                                                                                                                          
     477               0 :                 break;                                                                                                                                         
     478                 :                                                                                                                                                                
     479               0 :             case 'minute':                                                                                                                                     
     480                 :                 // ausgabe von dem was vor dem Minuten-Menü stehen soll                                                                                       
     481               0 :                 echo $this->minuteString." ";                                                                                                                  
     482                 :                 // generiere den Menü                                                                                                                         
     483                 :                 // setze den Variablen Namen über den später in $_POST daruf zugegriffen werden kann                                                         
     484               0 :                 echo "<p class='pForm'><select name='".$optionName."_minute'";                                                                                 
     485                 :                 // falls autoUpdate dann aktiviere das javascript                                                                                              
     486               0 :                 if ($this->autoUpdate === true) echo " onchange='document.getElementById[\"".$this->formName."\"].submit();'";                                 
     487               0 :                 echo ">\n";                                                                                                                                    
     488               0 :                 $i = 0;                                                                                                                                        
     489               0 :                 for ($i ; $i < 60 ; $i++) {                                                                                                                    
     490               0 :                     echo "<option ";                                                                                                                           
     491               0 :                     if ($i == $this->minute) echo "selected='selected'";                                                                                       
     492               0 :                     echo ">".$i."</option>\n";                                                                                                                 
     493               0 :                 }                                                                                                                                              
     494               0 :                 echo "</select></p>";                                                                                                                          
     495               0 :                 break;                                                                                                                                         
     496                 :             }                                                                                                                                                  
     497               0 :         }                                                                                                                                                      
     498                 :         /**                                                                                                                                                    
     499                 :          *                                                                                                                                                     
     500                 :          * @access public                                                                                                                                      
     501                 :          * @return void                                                                                                                                        
     502                 :          */                                                                                                                                                    
     503                 :         function defaultStrings() {                                                                                                                            
     504               0 :             $this->dayString = 'Tag';                                                                                                                          
     505               0 :             $this->monthString = 'Monat';                                                                                                                      
     506               0 :             $this->yearString = 'Jahr';                                                                                                                        
     507               0 :             $this->minuteString = 'Minute';                                                                                                                    
     508               0 :             $this->hourString = 'Stunde';                                                                                                                      
     509               0 :         }                                                                                                                                                      
     510                 :         /**                                                                                                                                                    
     511                 :          *                                                                                                                                                     
     512                 :          * @access public                                                                                                                                      
     513                 :          * @return void                                                                                                                                        
     514                 :          */                                                                                                                                                    
     515                 :         function clearStrings() {                                                                                                                              
     516               0 :             $this->dayString = '';                                                                                                                             
     517               0 :             $this->monthString = '';                                                                                                                           
     518               0 :             $this->yearString = '';                                                                                                                            
     519               0 :             $this->minuteString = '';                                                                                                                          
     520               0 :             $this->hourString = '';                                                                                                                            
     521               0 :         }                                                                                                                                                      
     522                 :     }                                                                                                                                                          

Generated by PHPUnit 3.2.21 and Xdebug 2.0.3 at Thu Nov 26 17:01:15 CET 2009.